home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / mcomm / comm.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-02  |  17.4 KB  |  390 lines
  1.  
  2. /////////////////////////////////////////////////////////////////////////////
  3. //                                                                         //
  4. //  COMM.HPP -- header file for C++ programs using MCOMM async routines.   //
  5. //    Zortech C++ 2.0, Turbo C++ 1.00 version.                             //
  6. //                                                                         //
  7. //    Mike Dumdei,  6 Holly Lane,  Texarkana TX  75503    (c) 1989,1990    //
  8. //                                                                         //
  9. /////////////////////////////////////////////////////////////////////////////
  10.  
  11. #if !defined(COMM_HPP)
  12. #define COMM_HPP
  13.  
  14. #ifndef MCOMM
  15.   #define _C_ cdecl
  16.   #define _V_ volatile
  17.   #define _F_ far
  18.   #if (__TURBOC__ && __HUGE__)
  19.     #define _N_
  20.   #else
  21.     #define _N_ near
  22.   #endif
  23.   #define MCOMM
  24. #endif
  25.  
  26. //////////////////////////////////////////////
  27. //  Return codes                            //
  28. //////////////////////////////////////////////
  29. #ifndef __ZTC__
  30.   #define   R_OK           0x0000
  31. #endif
  32. #define     R_NOMEM        0x0001
  33. #define     R_BAUDERR      0x0002
  34. #define     R_PARITYERR    0x0004
  35. #define     R_DTABITERR    0x0008
  36. #define     R_STPBITERR    0x0010
  37. #define     R_IRQUSED      0x0020
  38. #define     R_VCTRUSED     0x0040
  39. #define     R_NOPORT       0x0080
  40. #define     R_PORTUSED     0x0100
  41. #define     R_UARTERR      0x0200
  42.  
  43. #define     R_TXERR        (-1)
  44.  
  45. //////////////////////////////////////////////
  46. //  Interrupt bit masks                     //
  47. //////////////////////////////////////////////
  48. #define     IRQ2           0x04
  49. #define     IRQ3           0x08
  50. #define     IRQ4           0x10
  51. #define     IRQ5           0x20
  52. #define     IRQ6           0x40
  53. #define     IRQ7           0x80
  54.  
  55. //////////////////////////////////////////////
  56. //  Vector numbers                          //
  57. //////////////////////////////////////////////
  58. #define     VCTR2          0x0a
  59. #define     VCTR3          0x0b
  60. #define     VCTR4          0x0c
  61. #define     VCTR5          0x0d
  62. #define     VCTR6          0x0e
  63. #define     VCTR7          0x0f
  64.  
  65. //////////////////////////////////////////////
  66. //  Standard Comm Ports                     //
  67. //   Note - due to the ability to overload  //
  68. //   the open call, COM1 and COM2 are def-  //
  69. //   ined differently in the C++ version.   //
  70. //////////////////////////////////////////////
  71. #define     COM1        0
  72. #define     COM2        1
  73.  
  74. //////////////////////////////////////////////
  75. //  Defines for async_regs function         //
  76. //////////////////////////////////////////////
  77. #define     RXreg       0
  78. #define     TXreg       0
  79. #define     IERreg      1
  80. #define     IIDreg      2
  81. #define     FCRreg      2
  82. #define     LCRreg      3
  83. #define     MCRreg      4
  84. #define     LSRreg      5
  85. #define     MSRreg      6
  86. #define     LObaud      0
  87. #define     HIbaud      1
  88.  
  89. //////////////////////////////////////////////
  90. //  Miscellaneous bit masks                 //
  91. //////////////////////////////////////////////
  92. #define     B_DTR        0x0001
  93. #define     B_RTS        0x0002
  94.  
  95. /////////////////////////////////////////////////////////////////////////
  96. //  Status bit masks                                                   //
  97. /////////////////////////////////////////////////////////////////////////
  98.   //  S T A T 2  //
  99. #define     B_XUSE       0x0001   // using XON/XOFF protocol bit
  100. #define     B_XRXD       0x0002   // XOFF received bit
  101. #define     B_XSENT      0x0004   // XOFF sent bit
  102. #define     B_TXEMPTY    0x0008   // nothing to transmit bit
  103. #define     B_CTS        0x0010   // clear to send bit
  104. #define     B_DSR        0x0020   // data set ready bit
  105. #define     B_FLOWHALT   0x0040   // flow halt indicator bit
  106. #define     B_MNTR_CD    0x0080   // monitor CD bit
  107.  
  108.   //  S T A T 1  //
  109. #define     B_RXOVF      0x0100   // rx buffer overflow indic bit
  110. #define     B_OVERRUN    0x0200   // char overrun error bit
  111. #define     B_PARITY     0x0400   // parity error bit
  112. #define     B_FRAMING    0x0800   // framing error bit
  113. #define     B_BREAK      0x1000   // line break signal detected
  114. #define     B_THRE       0x2000   // used in interrupt hdlr (always 0)
  115. #define     B_RXEMPTY    0x4000   // rx buffer empty bit
  116. #define     B_CD         0x8000   // carrier detect bit mask
  117.  
  118.   //  S T A T 3  //
  119. #define     B_IGNERR     0x0001   // discard chars with par, frm'g errs
  120. #define     B_16550      0x0002   // 16550 detected
  121. #define     B_FIFO       0x0004   // 16550 FIFOs enabled
  122. #define     B_ORGFIFO    0x0008   // FIFOs were on when port was opened
  123. #define     B_FARBUFFER  0x0010   // using FAR ring buffers
  124. #define     B_XUSET      0x0020   // using XON/XOFF on txmt side bit
  125. #define     B_XUSER      0x0040   // using XON/XOFF on recv side bit
  126. #define     B_XONANY     0x0080   // accept any char for an XON
  127.  
  128.  
  129. /////////////////////////////////////////////////////////////////////////
  130. //                                                                     //
  131. //  A s y n c P o r t   C l a s s                                      //
  132. //                                                                     //
  133. //                    * * *  W A R N I N G  * * *                      //
  134. //     This class must have the port variables byte aligned.  As       //
  135. //     written, ZTC 2.0 will byte align this structure without the     //
  136. //     need to direct it to pack structures.  If you are using         //
  137. //     a different implementation of C++ be sure this data is          //
  138. //     byte aligned by your compiler.                                  //
  139. /////////////////////////////////////////////////////////////////////////
  140.  
  141. class AsyncPort
  142. {
  143.       // port variables
  144.   private:
  145.     int ComBase;          // base port address of for comm port
  146.     char IRQMask;         // mask for IRQ used by this port
  147.     char Vector;          // interrupt vector used by this port
  148.     char BPDSstr[10];     // current baud,parity,data,stop parms
  149.     int RxSize;           // size of receive bufr
  150.     int TxSize;           // size of transmit bufr
  151.     int RingSeg;          // segment of rx/tx bufrs (leave 0 for NEAR)
  152.     int RingOfst;         // offset of rx/tx bufrs, alias TxTop
  153.     int RxTop;            // ptr to begin of rx bufr, alias TxBtm
  154.     int RxBtm;            // ptr to end of rx bufr (end + 1)
  155.     int _V_ TxIn;         // ptr to where next 'put' goes
  156.     int _V_ TxOut;        // ptr to where next tx'd comes from
  157.     int _V_ TxFree;       // remaining tx bufr space
  158.     int _V_ RxIn;         // pointer to where next rx'd goes
  159.     int _V_ RxOut;        // ptr to where next 'get' comes from
  160.     int _V_ RxFree;       // remaining bytes in rx bufr space
  161.     int BaudDvsr;         // baud rate divisor
  162.     int XoffTrip;         // send XOFF when this many bytes left in rxbuf
  163.     int XonTrip;          // send XON when this many bytes left in rxbuf
  164.     int OldVctrOfst;      // OFST address of original interrupt vector
  165.     int OldVctrSeg;       // SEG address of original interrupt vector
  166.     int OldDvsr;          // original value of Baud Divisor Regs
  167.     char _V_ Stat2;       // secondary status byte
  168.     char _V_ Stat1;       // primary status byte
  169.     char _V_ TxStat;      // determines when tx_intrpts need turned on
  170.     char MSRMask;         // slcts bits in MSR montrd for flow cntrl
  171.     char _V_ MSRVal;      // present value of modem status register
  172.     char _V_ Stat3;       // another flag, used for XONANY char
  173.     char PDSinfo;         // parity, # dta bits, # stop bits
  174.     char StripMask;       // mask for high bit stripping
  175.     char XTxRptInit;      // initialization value for XTxRpt below
  176.     char _V_ XTxRpt;      // countdown val befr repeat tx of XOFF
  177.     char _V_ TxImmedChar; // char to be tx'd 1st opportunity
  178.     char HdlrUsed;        // assigned interrupt handler for this port
  179.     char Old8259Msk;      // original 8259 interrupt mask
  180.     char OldLCR;          // original Line Control Reg value
  181.     char OldMCR;          // original Modem Cntrl Reg value
  182.     char OldIER;          // original Interrupt Enable Reg value
  183.     int TxByteCnt;        // number bytes to send per tx interrupt
  184.     char FCRVal;          // FIFO control register data byte
  185.     char IERVal;          // interrupt enable register value
  186.     char _V_ MCRVal;      // modem control register value
  187.  
  188.       // declaration of default ring buffer variables
  189.     static int DefRxBufSz;      // default receive ring buffer size
  190.     static int DefTxBufSz;      // default transmit buffer size
  191.     static int DefMemType;      // default to NEAR or FAR memory flag
  192.  
  193.   public:
  194.     AsyncPort();                    // constructors
  195.     AsyncPort(int RxBufSz, int TxBufSz, int UseFarMem = 0);
  196.  
  197.     ~AsyncPort();                   // destructor
  198.  
  199.                                     // allocate ring buffers function
  200.     int AllocBuffers(int RxBufSz, int TxBufSz, int UseFarMem = 0);
  201.     int FreeBuffers();              // free ring buffers function
  202.                                     // reset default buffers function
  203.     static void SetDefaultBuffers(int RxDefSz, int TxDefSz, int DefMem = 0);
  204.  
  205.                                     // open with full port definition
  206.     int Open(int ComBase, int IRQNbr, int InterruptVctr, char *Params = "");
  207.     int Open(int ComN, char *Params = ""); // open COM1 or COM2
  208.  
  209.     int Close();                    // close & leave DTR/RTS in pre-open state
  210.     int Close(int DTR, int RTS);    // close with option to force DTR/RTS
  211.  
  212.     void Release();                 // disable interrupt operation
  213.     void Restart();                 // resume interrupt mode of operation
  214.  
  215.     void PortAddress(int BaseAdrs); // set port base address
  216.     int PortAddress();              // get port base address
  217.  
  218.     int Tx(char Ch);                // transmit character
  219.     int Tx(char *String);           // transmit string
  220.     int Tx(char *Block, int NbrBytes); // transmit block
  221.  
  222.     int Rx();                       // receive character
  223.     int Rx(char *Block, int MaxNbrBytes); // receive block until maxbytes
  224.                                     // rx blk until delim or maxbytes
  225.     int Rx(char *Block, int MaxNbrBytes, char Delim, int IncludeDelim = 1);
  226.  
  227.     int Peek(int Offset = 0);       // peek receive buffer (index opt)
  228.  
  229.     int Status(int Mask = 0xffff);  // get port status (Stat1/Stat2)
  230.     void Reset();                   // reset parity,framing,char/bufr overrun
  231.     char Error(int Mask = 0x0f);    // test for parity,frame,char/bufr overrun
  232.  
  233.     int Params(char *Params);       // set port parameters
  234.     char *Params();                 // get port parameters
  235.  
  236.     void RxFlush();                 // flush receive buffer
  237.     void TxFlush();                 // flush transmit buffer
  238.  
  239.     void HardFlow(int Mask);        // set/reset hardware flow options
  240.  
  241.     void XFlow(int Mask);           // set/reset XON/XOFF flow control
  242.     char XFlow();                   // read XON/XOFF flow settings (bitmapped)
  243.                                     // set XON/XOFF trip levels
  244.     int XTrip(int XoffLevel, int XonLevel, int RepeatLevel);
  245.     void XoffReset();               // forced reset of XOFF received condition
  246.     void XoffSet();                 // simulate XOFF received
  247.     char XoffRxd();                 // test for XOFF received
  248.     char XoffTxd();                 // test for XOFF transmitted
  249.  
  250.     void Dtr(int Enable);           // set/reset DTR line
  251.     void Rts(int Enable);           // set/reset RTS line
  252.     char Msr();                     // get value of modem status register
  253.     char Cts();                     // get status of CTS line
  254.     char Dsr();                     // get status of DSR line
  255.     char Carrier();                 // get status of carrier detect line
  256.  
  257.     void Break(int Enable);         // set or reset breaking condition
  258.     char Break();                   // check if break signal received
  259.  
  260.     char Regs(int UARTreg, int Value = -1); // raw R/W of UART regs
  261.  
  262.     int RxLevel();                  // get number bytes in receive buffer
  263.     int TxAvailable();              // get bytes available in transmit buffer
  264.     char TxEmpty();                 // test for transmit buffer empty
  265.  
  266.     void RxMask(char Mask);         // set strip mask for incoming chars
  267.     void FlushBadChars(int Flag);   // set handling for chars with errs
  268.     char FlushBadChars();           // get setting chars with errs
  269. };
  270.  
  271. /////////////////////////////////////////////////////////////////////////
  272. //  E X T E R N A L   A S M   F U N C T I O N S                        //
  273. /////////////////////////////////////////////////////////////////////////
  274.   extern "C" {
  275. int async_open(AsyncPort *, int, int, int, char *); // open async port
  276. int async_close(AsyncPort *);              // close async port
  277. int async_tx(AsyncPort *, char);           // transmit character
  278. int async_txblk(AsyncPort *, char *, int); // transmit a block
  279. int async_rx(AsyncPort *);                 // receive a character
  280. int async_rxblk(AsyncPort *, char *, int); // receive a block
  281. int async_rxblkch(AsyncPort *, char *, int, char, int); // rx blk till char
  282. int async_stat(AsyncPort *, int);          // get stat1/stat2 bytes
  283. int async_setbpds(AsyncPort *, char *);    // change line parameters
  284. void async_rxflush(AsyncPort *);           // flush the receive buffer
  285. void async_txflush(AsyncPort *);           // flush the transmit buffer
  286. void async_msrflow(AsyncPort *, int);      // set MSR related flw cntrl
  287. void async_xflow(AsyncPort *, int);        // XON/OFF protocl on/off
  288. void async_xoffclr(AsyncPort *);           // manually clr XOFF rx'd
  289. void async_xoffset(AsyncPort *);           // manually set XOFF rx'd
  290. void async_dtr(AsyncPort *, int);          // DTR on/off
  291. void async_rts(AsyncPort *, int);          // RTS on/off
  292. void async_sndbrk(AsyncPort *, int);       // Set/clr tx modem brk sgnl
  293. void async_stop(AsyncPort *);              // halts interrupt operation
  294. void async_restart(AsyncPort *);           // re-init an already open port
  295. int async_peek(AsyncPort *, int);          // peek indexed char in rx buffer
  296. int async_regs(AsyncPort *, int, int);     // direct read/write of port regs
  297. void async_FIFOrxlvl(AsyncPort *, int);    // set rx FIFO trigger level
  298. void async_FIFOtxlvl(AsyncPort *, int);    // set max sent per tx intrpt
  299.   }
  300.  
  301.  
  302. /////////////////////////////////////////////////////////////////////////
  303. //  D E F I N I T I O N    O F   I N L I N E   F U N C T I O N S       //
  304. /////////////////////////////////////////////////////////////////////////
  305.  
  306. inline void AsyncPort::SetDefaultBuffers(int DefRxSz,int DefTxSz,int DefMem)
  307.  { DefRxBufSz = DefRxSz, DefTxBufSz = DefTxSz, DefMemType = DefMem; }
  308. inline void AsyncPort::PortAddress(int BaseAdrs)
  309.  { ComBase = BaseAdrs; }
  310. inline int AsyncPort::PortAddress()
  311.  { return ComBase; }
  312. inline void AsyncPort::Release()
  313.  { async_stop(this); }
  314. inline void AsyncPort::Restart()
  315.  { async_restart(this); }
  316. inline int AsyncPort::Tx(char Ch)
  317.  { return (async_tx(this, Ch)); }
  318. inline int AsyncPort::Tx(char *Block, int NbrBytes)
  319.  { return (async_txblk(this, Block, NbrBytes)); }
  320. inline int AsyncPort::Rx()
  321.  { return (async_rx(this)); }
  322. inline int AsyncPort::Rx(char *Block, int MaxNbrBytes)
  323.  { return (async_rxblk(this, Block, MaxNbrBytes)); }
  324. inline int AsyncPort::Rx(char *Block, int MaxNbrBytes, char Delim,
  325.  int IncludeDelim)
  326.  { return (async_rxblkch(this, Block, MaxNbrBytes, Delim, IncludeDelim)); }
  327. inline int AsyncPort::Peek(int Offset)
  328.  { return (async_peek(this, Offset)); }
  329. inline int AsyncPort::Status(int Mask)
  330.  { return (async_stat(this, Mask)); }
  331. inline void AsyncPort::Reset()
  332.  { Stat1 &= '\xe0'; }
  333. inline char AsyncPort::Error(int Mask)
  334.  { return (Stat1 & Mask); }
  335. inline int AsyncPort::Params(char *Params)
  336.  { return (async_setbpds(this, Params)); }
  337. inline char * AsyncPort::Params()
  338.  { return BPDSstr; }
  339. inline void AsyncPort::RxFlush()
  340.  { async_rxflush(this); }
  341. inline void AsyncPort::TxFlush()
  342.  { async_txflush(this); }
  343. inline void AsyncPort::HardFlow(int Mask)
  344.  { async_msrflow(this, Mask); }
  345. inline void AsyncPort::XFlow(int Mask)
  346.  { async_xflow(this, Mask); }
  347. inline char AsyncPort::XFlow()
  348.  { return (Stat3 & '\xe0'); }
  349. inline void AsyncPort::XoffReset()
  350.  { async_xoffclr(this); }
  351. inline void AsyncPort::XoffSet()
  352.  { async_xoffset(this); }
  353. inline char AsyncPort::XoffRxd()
  354.  { return (TxStat & '\x02'); }
  355. inline char AsyncPort::XoffTxd()
  356.  { return (Stat2 & '\x04'); }
  357. inline void AsyncPort::Dtr(int Enable)
  358.  { async_dtr(this, Enable); }
  359. inline void AsyncPort::Rts(int Enable)
  360.  { async_dtr(this, Enable); }
  361. inline char AsyncPort::Msr()
  362.  { return MSRVal; }
  363. inline char AsyncPort::Cts()
  364.  { return (MSRVal & '\x10'); }
  365. inline char AsyncPort::Dsr()
  366.  { return (MSRVal & '\x20'); }
  367. inline char AsyncPort::Carrier()
  368.  { return (MSRVal & '\x80'); }
  369. inline void AsyncPort::Break(int Enable)
  370.  { async_sndbrk(this, Enable); }
  371. inline char AsyncPort::Break()
  372.  { return (Stat1 & '\x10'); }
  373. inline char AsyncPort::Regs(int UARTreg, int Value)
  374.  { return async_regs(this, UARTreg, Value); }
  375. inline int AsyncPort::RxLevel()
  376.  { return (RxSize - RxFree); }
  377. inline int AsyncPort::TxAvailable()
  378.  { return (TxFree); }
  379. inline char AsyncPort::TxEmpty()
  380.  { return (TxStat & '\x08'); }
  381. inline void AsyncPort::RxMask(char Mask)
  382.  { StripMask = Mask; }
  383. inline void AsyncPort::FlushBadChars(int Flag)
  384.  { (Flag) ? (Stat3 |= 1) : (Stat3 &= '\xfe'); }
  385. inline char AsyncPort::FlushBadChars()
  386.  { return (Stat3 & 1); }
  387.      
  388. #endif          // COMM_HPP
  389.  
  390.